package com.ceba.test.modules.filemanage.service;

import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.ceba.base.constants.FileClassConstants;
import com.ceba.base.enums.GFileContentTypeEnum;
import com.ceba.base.helper.LoggerHelper;
import com.ceba.base.utils.IDSFileUtils;
import com.ceba.base.utils.ToPdfUtils;
import com.ceba.base.web.response.ResultJson;
import com.ceba.base.web.service.IBaseService;
import com.ceba.cebautils.StringUtil;
import org.apache.commons.lang.math.NumberUtils;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.alibaba.fastjson.JSON;
import com.ceba.test.base.configs.CebaConfig;
import com.ceba.test.base.configs.CebaPathUtil;
import com.ceba.test.base.enums.FileFlagEnum;
import com.ceba.test.base.enums.ResultStatusEnum;
import com.ceba.test.base.language.ResourceUtils;
import com.ceba.test.base.utils.CebaFileManageUtil;
import com.ceba.test.modules.filemanage.dao.FileManagerDao;
import com.ceba.test.modules.filemanage.dto.VFileObject;
import com.ceba.test.modules.filemanage.entity.GFile;
import com.ceba.test.modules.filemanage.entity.GFileRelaction;
import com.ceba.test.modules.filemanage.entity.GFolder;
import com.ceba.test.modules.filemanage.entity.MergeFile;

import abc.ID;
import abc.data.DataTable;

public class FileManagerService extends IBaseService {

	static Logger logger = LoggerFactory.getLogger(FileManagerService.class);

	private FileManagerDao fileManagerDao;

	/**
	 * 获取目录的子文件与子目录（当前目录的）
	 *
	 * @param pathOrId 目录的路径或目录ID
	 *
	 * @return
	 * @throws Exception
	 */
	public List<VFileObject> getFolder(String pathOrId) {
		return fileManagerDao.getFolder(pathOrId);
	}



	/**
	 * 获取文件信息json
	 *
	 * @param path
	 * @param action
	 *            读取数据的动作指令
	 *
	 * @return
	 * @throws Exception
	 */
	public String getFolder(String path, String action) {
		try{
			List<VFileObject> vfList = fileManagerDao.getFolder(path, action);
			return fileManagerDao.getFilePathJson(vfList, path);
		}catch(Exception e){
			LoggerHelper.error(logger, e, "");
			return "{}";
		}
	}

	/**
	 * 获取某一个文件夹关联的拓展目录
	 *
	 * @param path
	 * @param json
	 *            原文件夹的目录结构
	 * @return
	 * @throws Exception
	 */
	public JSONObject getRelationFolder(String path, JSONObject json) {
		try {
			String relID = fileManagerDao.getRelationFolderIdByPath(path);
			if(!StringUtil.isEmptyString(relID)){
				String[] arr = relID.split(";");
				for (int i = 0; i < arr.length; i++) {
					if (!arr[i].equals("")) {
						json = fileManagerDao.addRelationFolder(arr[i], json);
					}

				}
			}
			return json;
		} catch (Exception e) {
			LoggerHelper.error(logger, e, "");
			return json;
		}
	}


	/**
	 * 查询，全文和目录检索
	 *
	 * @param path
	 * @param key
	 *            查询关键字
	 *
	 * @return
	 * @throws Exception
	 */
	public String getFullTextSearchFolder(String path, String key)  {
		return fileManagerDao.getFullTextSearchFolder(path, key);
	}

	/**
	 * 根据ID获取文件或目录的信息
	 *
	 * @param id
	 * @return
	 * @
	 */
	public VFileObject getFileInfo(String id,String path){
		return fileManagerDao.getFileInfo(id,path);
	}

	/**
	 * 根据ID获取文件
	 *
	 * @param id
	 * @return
	 * @
	 */
	public GFileRelaction getGFileRelactionById(String id){
		return fileManagerDao.getGFileRelactionById(id);
	}


	/**
	 * 获取一个FM目录下的所有目录结构
	 * @param fmPathOrId 目录路径或目录Id
	 * @param key 查询的关键字
	 * @return
	 */
	public List<VFileObject> getFMFoldersList(String fmPathOrId,String key)  {
		return fileManagerDao.getFMFoldersList(fmPathOrId,key);
	}

	/**
	 * 获取一个FM目录下的所有文件列表
	 * @param folderId 目目录Id
	 * @param key 查询的关键字
	 * @return
	 */
	public List<VFileObject> getFMFilesListByFolderId(String folderId,String key)  {
		return fileManagerDao.getFMFilesListByFolderId(folderId,key);
	}


	/**
	 * 根据传过来的JSON获取所有的文件
	 * @param filesJson 文件json,包含文件Id或文件包Id
	 * @return 所有文件的datatable
	 */
	public List<VFileObject> getFMFilesByJson(String filesJson)  {
		return fileManagerDao.getFMFilesByJson(filesJson);
	}

	/**
	 * 搜索目录下面的所有文件，这里获取的是FM的关联文件
	 *
	 * @param fmPath
	 *            查询的目录
	 * @param key 关键字
	 *
	 * @return
	 * @
	 */
	public DataTable searchFMFilesInFolder(String fmPath,String key,Boolean bRelation)  {
		return fileManagerDao.searchFMFilesInFolder(fmPath,key,bRelation);
	}

	/**
	 * 删除一个文件夹里面所有的内容
	 *
	 * @param fmPath
	 *            删除目录
	 * @return
	 * @
	 */
	public Boolean deleteFolder(String fmPath)  {
		return fileManagerDao.deleteFolder(fmPath);
	}

	/**
	 * 删除一个Fm关联文件
	 *
	 * @param relationId
	 *            删除目录
	 * @return
	 * @
	 */
	public Boolean deleteFmFile(String relationId) {
		return fileManagerDao.deleteFmFile(relationId);
	}


	/**
	 * 删除一组文件，文件也可以是文件夹
	 * @param filesJson 文件json
	 * @return
	 * @
	 */
	public Boolean deleteFiles(String filesJson)  {
		return fileManagerDao.deleteFiles(filesJson);
	}

	/**
	 * 删除物理路径文件
	 * @param fileId 各种关联文件ID；
	 * @return
	 */
	public Boolean deletePhysicalFile(String fileId)  {
		return fileManagerDao.deletePhysicalFile(fileId);

	}


	/**
	 * 文件夹是否存在,要特定用户
	 *
	 * @param path
	 *            目录路径
	 * @return
	 * @
	 */
	public boolean existDirByUser1(String path,String loginUserId){
		return fileManagerDao.existDirByUser(path, loginUserId);
	}
	/**
	 * 文件夹下面是否存在子文件或者子文件夹
	 *
	 * @param id
	 * @param path
	 * @return
	 * @
	 */
	public boolean existChild(String id, String path,String loginUserId)  {
//		String userId = UserUtils.getUserId();
		boolean b = false;
		try {
			if (fileManagerDao.existChildFile(id,loginUserId)) {
				b = true;
			} else {
				if (fileManagerDao.existChildDir(path,loginUserId)) {
					b = true;
				}
			}
			return b;
		} catch (Exception e) {
			LoggerHelper.error(logger, e, "");
			return b;
		}
	}

	/**
	 * 获取复制到目录结构
	 *
	 * @param path
	 * @return
	 * @
	 */

	public String getCopyFolderList(String path)  {
		return fileManagerDao.getCopyFolderList(path);
	}

	/**
	 * 给当前目录加一个当日目录
	 *
	 * @param path
	 *            目录路径
	 * @return
	 * @
	 */
	public boolean addDateDir(String path,String loginUserId)  {
		return fileManagerDao.addDateDir(path,loginUserId);
	}

	/**
	 * 有一些默认的文件夹是添加报告目录中
	 *
	 * @param parentPath
	 *            父级目录路径
	 * @return
	 * @
	 */
	public Boolean addDefalutRelationToReport(String parentPath,String loginUserId)  {
		return fileManagerDao.addDefalutRelationToReport(parentPath,loginUserId);
	}


	/**
	 * 添加一个签名目录
	 *
	 * @return
	 * @
	 */
	public boolean addSignDir(String loginUserId)  {
		return fileManagerDao.addSignDir(loginUserId);
	}

	/**
	 * 获取一个报告下面的所有PDF文件，主要是作为正式报告
	 *
	 * @return
	 * @
	 */
	public String getReleaseReportListJson(String reportId,String loginUserId)  {
		return fileManagerDao.getReleaseReportListJson(reportId,loginUserId);
	}
	/**
	 * 获取一个报告下面的所有PDF文件，主要是作为正式报告
	 *
	 * @return
	 * @
	 */
	public String getReleaseReportRoleListJson(String reportId,String loginUserId)  {
		return fileManagerDao.getReleaseReportRoleListJson(reportId,loginUserId);
	}
	/**
	 * 更加ID获取文件url地址,ID可能是报告ID或关联文件ID，文件ID
	 *
	 * @return
	 * @
	 */
	public String getFileUrlPath(String id) {
		return fileManagerDao.getFileUrlPath(id);
	}

	/**
	 * 更加ID获取文件url地址
	 *
	 * @return
	 * @throws Exception
	 */
	public String getFolderUrlPath(String id) throws Exception{
		return fileManagerDao.getFolderUrlPath(id);
	}

	/**
	 * 根据ID获取文件物理地址,ID可能是报告ID或关联文件ID，文件ID
	 *
	 * @return
	 */
	public GFile getFilePath(String id)  {
		return fileManagerDao.getFilePath(id);
	}

	/**
	 * 获取一个文件的datatable文件，同时他多出来一个关联文件名g_file_relaction.FILE_NAME AS
	 * RELATION_FILE_NAME
	 *
	 * @param id
	 * @return
	 */

	public List<VFileObject> getFileInfosById(String id)  {
		return fileManagerDao.getFileInfosById(id);
	}


	/**
	 * 把一个文件添加到数据库中,并建立文件关联
	 *
	 * @param fileRelationId
	 *            ID，如果为空，自动获取
	 * @param fileId
	 *            文件ID，必须存在；
	 * @param fileName
	 *            文件名
	 * @param folderId
	 *            文件目录，必须存在；；
	 * @return
	 * @throws Exception
	 */

	public Boolean addFileRelationRecord(String fileRelationId, String fileId, String fileName, String folderId,String flag,String loginUserId,String storageId){
		return fileManagerDao.addFileRelationRecord(fileRelationId, fileId, fileName, folderId, flag,loginUserId,storageId);
	}


	/**
	 * 更新一个relation文件的相关的签名Id
	 *
	 * @param fileRelationId
	 * @param signFileId 签名文件的g_file.ID
	 * @return
	 * @throws Exception
	 */

	public Boolean updataRelationFileSign(String fileRelationId,String signFileId){
		return fileManagerDao.updataRelationFileSign(fileRelationId, signFileId);
	}

	/**
	 * 把一个文件添加到g_file中
	 *
	 * @return
	 * @throws Exception
	 */
	public Boolean addFileRecord(GFile gf){
		return fileManagerDao.addFileRecord(gf);
	}


	/**
	 *当pdf报告中的内容插入到g_file 出现特殊字符  无法插入的零时解决办法
	 *
	 */
	public Boolean addFileRecordEorr(GFile gf){
		return fileManagerDao.addFileRecordEorr(gf);
	}

	/**
	 * 把一个文件添加到g_file中，并且闯入文档内容，主要用于一些已经读取过全文的，做盖章、签名等文档添加到g_file
	 *
	 * @return
	 * @throws Exception
	 */
	public Boolean addFileRecordByDocumentText(GFile gf){
		return fileManagerDao.addFileRecordByDocumentText(gf);
	}

	/**
	 * 把一个文件添加到数据库中insert语句,不写读取报告内容
	 *
	 * @return
	 * @throws Exception
	 */
	public Boolean addFileRecordNoDocumentText(GFile gf)  {
		return fileManagerDao.addFileRecordNoDocumentText(gf);
	}


	/**
	 * 拷贝文件
	 * @param relactionFileId 要拷贝文件的关联ID
	 * @param folderId 拷贝目录的ID
	 * @param fileName 拷贝的文件名
	 * @return
	 * @throws Exception
	 */
	public Boolean copyFile(String relactionFileId, String folderId, String fileName,String loginUserId)  {
		return fileManagerDao.copyFile(relactionFileId, folderId, fileName,loginUserId);
	}

	/**
	 * 在一个目录中是否存在相同文件名，如果存在这把这个文件名更改，主要用于复制文件，添加FM记录
	 * @param fileName 文件名
	 * @param folderId 目录ID
	 * @return
	 */
	public String getFileNameInFolder(String fileName,String folderId) {
		return fileManagerDao.getFileNameInFolder(fileName, folderId);
	}


	/**
	 * 拷贝目录
	 * @param copyFolderId 要拷贝目录ID
	 * @param toFolderId 目标目录的ID
	 * @param name 拷贝目录名
	 * @return
	 * @throws Exception
	 */
	public Boolean copyFolder1(String copyFolderId, String toFolderId, String name,String loginUserId ) {
		return fileManagerDao.copyFolder(copyFolderId, toFolderId, name,loginUserId);
	}


	/**
	 * 拷贝一组文件，文件也可以是文件夹
	 * @param filesJson 文件json
	 * @param toFolderId 拷贝目录的ID
	 * @return
	 * @throws Exception
	 */
	public Boolean copyFiles(String filesJson, String toFolderId,String loginUserId)  {
		try {
			JSONArray json=new JSONArray (filesJson);
			for(int i=0;i<json.length();i++){
				JSONObject j =json.getJSONObject(i);
				if(j.getString("type").equals("dir")){
					copyFolder(j.getString("id"), toFolderId, "", loginUserId);
				}
				else {
					copyFile(j.getString("id"), toFolderId, "", loginUserId);
				}
			}
			return true;
		} catch (JSONException e) {
			LoggerHelper.error(logger, e, "");
			return false;
		}


	}



	/**
	 * 剪切文件
	 * @param relactionFileId 要剪切文件的关联ID
	 * @param folderId 剪切目录的ID
	 * @param fileName 剪切的文件名
	 * @return
	 * @throws Exception
	 */
	public Boolean  cutFile(String relactionFileId, String folderId, String fileName,String loginUserId) {
		try {
			if(copyFile(relactionFileId, folderId, fileName,loginUserId)){
				return deleteFmFile(relactionFileId);
			}
		} catch (Exception e) {
			LoggerHelper.error(logger, e, "");
		}
		return false;
	}


	/**
	 * 剪切目录
	 * @param cutFolderId 要剪切目录ID
	 * @param toFolderId 剪切目录的ID
	 * @param folderName 变更的目录名
	 * @return
	 * @throws Exception
	 */
	public Boolean cutFolder(String cutFolderId, String toFolderId, String folderName,String loginUserId)  {
		try {
			if(copyFolder(cutFolderId, toFolderId, folderName,loginUserId)){
				String fmPath= fileManagerDao.getFieldValue("g_folder",cutFolderId,"NAME");
				//SqlSessionManager.getFieldStringValue("SELECT NAME FROM g_folder WHERE ID='"+cutFolderId+"'");
				return deleteFolder(fmPath);
			}
		} catch (Exception e) {
			LoggerHelper.error(logger, e, "");
		}
		return false;
	}

	/**
	 * 剪切一组文件，文件也可以是文件夹
	 * @param filesJson 文件json
	 * @param toFolderId 拷贝目录的ID
	 * @return
	 * @throws Exception
	 */
	public Boolean cutFiles(String filesJson, String toFolderId,String loginUserId)  {
		try {
			JSONArray json=new JSONArray (filesJson);
			for(int i=0;i<json.length();i++){
				JSONObject j =json.getJSONObject(i);
				if(j.getString("type").equals("dir")){
					cutFolder(j.getString("id"), toFolderId, "",loginUserId);
				}
				else {
					cutFile(j.getString("id"), toFolderId, "",loginUserId);
				}
			}
			return true;
		} catch (JSONException e) {
			LoggerHelper.error(logger, e, "");
			return false;
		}


	}

	/**
	 * 当前文件夹是否有权限操作
	 *
	 * @param pathOrID
	 *            路径或ID
	 * @return
	 */
	public Boolean isMyFolder(String pathOrID,String loginUserId) {
		return fileManagerDao.isMyFolder(pathOrID,loginUserId);
	}

	/**
	 * 当前文件是否是我创建的
	 *
	 * @param pathOrID
	 *            路径或ID
	 * @return
	 */
	public Boolean isMyFile(String pathOrID,String loginUserId) {
		return fileManagerDao.isMyFile(pathOrID,loginUserId);
	}

	/**
	 * 文件转PDF
	 *
	 * @param folderID
	 *            路径或ID
	 * @return
	 * @throws Exception
	 */
	public Boolean toPDF(String fileID, String folderID,String loginUserId,String storageAddressId,String path,String verPath)  {
		return fileManagerDao.toPDF(fileID, folderID,loginUserId,storageAddressId,path,verPath);
	}

	/**
	 * 添加一个目录
	 *
	 * @return
	 * @throws Exception
	 */
	public boolean addFolder(GFolder gFolder) {
		return fileManagerDao.addFolder(gFolder);
	}

	/**
	 * 根据虚拟路径建立一组目录
	 *
	 * @param path
	 *            目录路径
	 * @param classString
	 *            分类
	 * @return
	 * @throws Exception
	 */
	public Map<String, String> addFolders(String path,String parentPath,String fmRootFolderPath, String classString,String loginUserId) {
		return fileManagerDao.addFolders(path, parentPath, fmRootFolderPath, classString,loginUserId);
	}

	/**
	 * 目录更名
	 *
	 * @param oldPath
	 *            原目录路径
	 * @param newFolderName
	 *            新目录名
	 * @param classString
	 *            分类
	 * @return
	 * @throws Exception
	 */
	public boolean updateFolderName(String id, String oldPath, String newFolderName, String classString,String loginUserId) {
		return fileManagerDao.updateFolderName(id, oldPath, newFolderName, classString,loginUserId);
	}

	/**
	 * FM文件更名
	 * @param id
	 * @param oldPath
	 * @param newName
	 * @return
	 */
	public boolean updateFmFileName(String id, String oldPath, String newName,String loginUserId){
		return fileManagerDao.updateFmFileName(id, oldPath, newName,loginUserId);
	}

	/**
	 * 把一个目录打包成Zip文件
	 *
	 * @param folderID
	 *            文件目录ID
	 * @return
	 * @throws Exception
	 */
	public String getFolderZip(String folderID,String zipPath ,String type)  {
		return fileManagerDao.getFolderZip(folderID,zipPath ,type);
	}

	/**
	 * 把一个目录打包成Zip文件
	 *
	 * @param folderPath
	 * @param folderName
	 *            压缩包名字
	 * @return -1代表打包文件超过25M，
	 * @throws Exception
	 */
	public String getFolderZip(String folderPath, String folderName)   {
		return fileManagerDao.getFolderZip(folderPath, folderName,null);
	}


	/**
	 * 下载一组选择的文件,包括文件夹
	 * @param jsonFiles 文件json
	 * @param folderName 压缩包名，也是文件夹名
	 * @return -1代表打包文件超过25M，
	 * @throws Exception
	 */
	public String getZipFiles(String jsonFiles, String folderName,String zipPath)  {
		return fileManagerDao.getZipFiles(jsonFiles, folderName,zipPath);
	}


	/**
	 * 把一个压缩包解压,并转存到文件管理器中（转数据库）
	 *
	 * @param zipPath
	 *            zip包物理路径
	 * @param fmRootFolderPath
	 *            filemanage导入根目录虚拟路径
	 * @return
	 * @throws Exception
	 */
	public Boolean unZipToFileManager(String zipPath, String fmRootFolderPath,String loginUserId,String toFolderPath, String tempPath,String storageAddressId,String verPath,String fmPath) {

		return fileManagerDao.unZipToFileManager(zipPath, fmRootFolderPath,loginUserId, loginUserId, toFolderPath, tempPath,storageAddressId,verPath,fmPath);
	}


	/**
	 * 这个文件是否被数字证书签章过，如果SIGN_FILE_MORE设置是true，可以允许同一个文件多签
	 * @param fmFileId g_file_relaction.ID
	 * @param fileId g_file.ID
	 * @return true代表已签过，false代表未签过
	 */
	public Boolean boolSignFMFile(String fmFileId,String fileId) {
		return fileManagerDao.boolSignFMFile(fmFileId, fileId);
	}



	/**
	 * 通过路径寻找folderId
	 * @param path
	 * @return
	 */
	public String getFolderIdByPath(String path) {
		return fileManagerDao.getFolderIdByPath(path);
	}

	/**
	 * 删除不需要的缓存文件
	 * 0--成功
	 * 1--没有需要删除的缓存文件
	 * 100--删除时出现异常
	 * 其他情况，返回删除的个数
	 * @return
	 */
	public String deleteTempUse() {
		int count = fileManagerDao.deleteTempUse();
		if(count <0){
			if(count == -1){
				return "1";
			}else if(count == -2){
				return "100";
			}
		}
		return ResourceUtils.getMessage("MODULES_DELETED")+count+ResourceUtils.getMessage("MODULES_A_FILE");
	}


	/**
	 * 合并文件
	 * @param //filePath 合并后的文件的目录
	 * @param fileName 合并后的文件名称
	 * @return JSON数据返回
	 */
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public String mergeFile(String fileName,String savePath,MergeFile[] mergeFiles,String loginUserId,String  storageAddressId,String verPath) {
		ResultJson resultJson=new ResultJson();
		try {
			ArrayList<String> filePathList=new ArrayList<>();
			Map<String, Object> fileMap=new HashMap();
			String folderid=null;
			Arrays.sort(mergeFiles,new ManagerComparator());
			//2.合并文件
			for(int i=0;i<mergeFiles.length;i++){
				MergeFile mergeFile=mergeFiles[i];
				folderid=mergeFile.getFolderid();
				filePathList.add(mergeFile.getTemFilePath());
			}
			boolean bool = ToPdfUtils.mergePdfFiles(filePathList, savePath);
			//3.取出合并后的文件所存放的文件夹ID
			String fileId = ID.getGuid();
			if(bool){
				//4.在g_file表中添加文件记录
				GFile gf = GFile.createGFile(fileId, fileName+".pdf",
						GFileContentTypeEnum.PDF.getContentType(), "", savePath, FileClassConstants.MERGE,loginUserId,storageAddressId, verPath);
				addFileRecord(gf);
				//5.在g_file_ralaction表中添加文件与文件夹关联记录
				addFileRelationRecord(null,fileId,fileName+".pdf",folderid,FileFlagEnum.MERGE.getFlag(), loginUserId,storageAddressId);
				resultJson.setStatus(ResultStatusEnum.CG.getCode());
				//6.取出文件
				GFile gFile = fileManagerDao.getGFileByGFileId(fileId);
				fileMap.put("CLASS", gFile.getClassS());
				fileMap.put("CONTENT_TYPE",gFile.getContentType());
				fileMap.put("CREATE_TIME", gFile.getCreateTime());
				fileMap.put("CREATE_USER", gFile.getCreateUser());
				fileMap.put("FILE_NAME", gFile.getFileName());
				fileMap.put("FILE_PATH", gFile.getFilePath());
				fileMap.put("ID", gFile.getId());
				fileMap.put("SIZE", gFile.getSize());
				fileMap.put("VIRTUAL_PATH", gFile.getVirtualPath());
				resultJson.setData(fileMap);

				//是否删除合并后的原文件
				for(int i=0;i<mergeFiles.length;i++){
					MergeFile mergeFile=mergeFiles[i];
					String fileID=mergeFile.getFileID();
					if(mergeFile.isIsremove()){
						deleteFmFile(fileID);
					}
				}
			}else{
				resultJson.setStatus(ResultStatusEnum.SB.getCode());
				resultJson.setMessage(ResourceUtils.getMessage("MODULES_FAIL"));
			}
		} catch (Exception e) {
			LoggerHelper.error(logger, e, "");
		}
		return JSON.toJSONString(resultJson);
	}


	/**
	 * 验证文件是否能转换为PDF
	 * @param fileInfoMap
	 * @return
	 */
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public String validFileConversionPDF(Map<Integer, String> fileInfoMap,String tempBaseFilePath) {
		Map<String,String> filePathMap=new HashMap<>();
		ResultJson resultJson=new ResultJson();
		try{
			boolean bools=false;
			String folderid=null;
			for(int i=0;i<fileInfoMap.size();i++){
				String fileID=fileInfoMap.get(i+1);
				fileManagerDao.getFieldValue("g_file", "select FILE_ID FROM g_file_relaction WHERE ID='"+fileID+"'", "FILE_PATH");
				String file_path=fileManagerDao.filePath(fileID);
				if(!bools){
					folderid=fileManagerDao.fileID(fileID);
					bools=true;
				}
				filePathMap.put(fileID+"-"+i,file_path);
			}
			List<Map<String,Object>> fileInfoList=new ArrayList();
			//文件转换为PDF
			for(String fileID:filePathMap.keySet()){
				if(StringUtil.isEmptyString(fileID)){continue;}
				String filePath=filePathMap.get(fileID);
				if(StringUtil.isEmptyString(filePath)){continue;}
				Map<String, Object> filePathInfoMap=new HashMap<String,Object>();
				String fileName=new File(filePath).getName();
				String tempFilePath;
				boolean bool;
				if(!".pdf".equals(fileName.substring(fileName.lastIndexOf(".")).toLowerCase())){
					String prefix=fileName.substring(0,fileName.lastIndexOf("."));
					tempFilePath= tempBaseFilePath+folderid+File.separator+prefix+".pdf";
					IDSFileUtils.createDir(tempBaseFilePath+folderid+File.separator);
					System.out.println("转换为pdf的文件："+filePath);
					bool=ToPdfUtils.fileToPdf(filePath, tempFilePath);
					System.out.println("转换成功失败："+bool);
				}else{
					bool=true;
					tempFilePath=filePath;
				}
				String[] fileIDs=fileID.split("-");
				filePathInfoMap.put("fileID", fileIDs[0]);//转换文件ID
				filePathInfoMap.put("number", fileIDs[1]);//转换文件
				filePathInfoMap.put("status", bool);//转换是否成功
				filePathInfoMap.put("tempFilePath", tempFilePath);//转换成功后的临时目录
				filePathInfoMap.put("folderid", folderid);//转换文件夹ID
				fileInfoList.add(filePathInfoMap);
			}
			resultJson.setStatus(ResultStatusEnum.CG.getCode());
			resultJson.setData(fileInfoList);
		} catch (Exception e) {
			LoggerHelper.error(logger, e, "");
			resultJson.setStatus(ResultStatusEnum.SB.getCode());
		}
		return JSON.toJSONString(resultJson);
	}


	/**
	 * 加载配置参数
	 * @return
	 */
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public static String loadConfig() {
		ResultJson resultJson=new ResultJson();
		resultJson.setStatus(ResultStatusEnum.CG.getCode());
		Map<String, Object> paramMap=new HashMap();
		paramMap.put("MERGE_MAX_COUNT", NumberUtils.toInt(CebaConfig.MERGE_MAX_COUNT));
		resultJson.setData(paramMap);
		return JSON.toJSONString(resultJson);
	}

	/*
	 * 根据用户id和目录id获取目录是否创建
	 */
	public long getCountOfFolderById(String userId,String foldId) {
		return fileManagerDao.getCountOfFolderById(userId,foldId);
	}

	/*
	 * 根据用户id和文件关联id，获取文件
	 */
	public long getCountOfGFileRelactionById(String userId, String fileRelactionId) {
		return fileManagerDao.getCountOfGFileRelactionById(userId,fileRelactionId);
	}

	/*
	 * 根据目录id获取文件路径
	 */
	public String getPathOfFolderById(String userId, String id) {
		return fileManagerDao.getPathOfFolderById(userId,id);
	}

	/*
	 * 根据条件获取目录字段值
	 */
	public String getFolderFieldValueByFolderPath(String fieldName,String query) {
		return fileManagerDao.getFolderFieldValueByFolderPath(fieldName,query);
	}

	/*
	 * 根据文件名+目录路径获取文件对象
	 */
	public GFileRelaction getGFRelactionByFolderPathAndFileName(String fileName,String virtualPath){
		return fileManagerDao.getGFRelactionByFolderPathAndFileName(fileName,virtualPath);
	}

	/*
	 * 根据条件更新g_file
	 */
	public boolean updateGFileByQuery(String updates,String condition){
		return fileManagerDao.updateGFileByQuery(updates,condition);
	}

	/*
	 * 根据用户ID+虚拟路径名获取文件目录
	 */
	public GFolder getGFolderByUserIdAndVirtualPath(String userId,String virtualPath){
		return fileManagerDao.getGFolderByUserIdAndVirtualPath(userId,virtualPath);
	}


	/**
	 *
	 * @param reportId
	 * @return
	 */
	public JSONArray getFileRoleListJson(String reportId){
		return fileManagerDao.getFileRoleListJson(reportId);
	}


	/**
	 * 取得报告的原始文件
	 * @param reportid
	 * @return
	 */
	public JSONArray reportOriginalFile(String reportid){
		return fileManagerDao.reportOriginalFile(reportid);
	}

	/**
	 * 根据 g_file 表的id 取得 g_file_ralation id
	 * @param fileidArray
	 * @return
	 */
	public String getRelationFile(String[] fileidArray){
		return fileManagerDao.getRelationFile(fileidArray);
	}


	/**
	 * 文件夹是否存在,要特定用户
	 *
	 * @param path
	 *            目录路径
	 * @return
	 * @
	 */
	public boolean existDirByUser(String path,String userId){
		return	fileManagerDao.existDirByUser(path, userId);
	}

	/**
	 * 拷贝目录
	 * @param copyFolderId 要拷贝目录ID
	 * @param toFolderId 目标目录的ID
	 * @param name 拷贝目录名
	 * @return
	 * @throws Exception
	 */
	public Boolean copyFolder(String copyFolderId, String toFolderId, String name,String loginUserId) {
		return	fileManagerDao.copyFolder(copyFolderId, toFolderId, name, loginUserId);
	}

	public String getFieldStringValue(String userId,String reportId) throws Exception{
		return fileManagerDao.getFieldStringValue(userId, reportId);
	}

	/**
	 * @param fileId
	 * @return
	 */
	public  GFileRelaction getFileRelactionById(String fileId){
		return fileManagerDao.getFileRelactionById(fileId);
	}

	/**
	 * 判断签名文件是否合格
	 * @param relaction_id
	 */
	public GFileRelaction isSignFile(String relaction_id) {
		return fileManagerDao.isSignFile(relaction_id);
	}

	/**
	 * @return
	 * @throws Exception
	 */
	public VFileObject getFileIdFilePath(String fileId){
		return fileManagerDao.getFileIdFilePath(fileId);
	}

	public FileManagerDao getFileManagerDao() {
		return fileManagerDao;
	}

	public void setFileManagerDao(FileManagerDao fileManagerDao) {
		this.fileManagerDao = fileManagerDao;
	}

	class ManagerComparator implements Comparator<MergeFile>{
		@Override
		public int compare(MergeFile o1, MergeFile o2) {
			if(o1.getNumber()>o2.getNumber()){
				return 1;
			}else{
				return -1;
			}
		}


	}

}
